package com.dragon.codefx.utils;

import com.dragon.codefx.dataBase.controller.vo.ConnectionVO;
import com.dragon.codefx.dataBase.entity.DatabaseConfigEntity;
import lombok.extern.slf4j.Slf4j;

import java.sql.Connection;
import java.sql.SQLException;

/**
 * 数据库工具
 * @author lsc
 * @date 2024/11/29 16:39
 **/
@Slf4j
public class JdbcUtil {
    /**
     * 数据库类型枚举
     */
    public enum DatabaseType {
        MYSQL, ORACLE, SQLSERVER, POSTGRESQL, DB2, SQLITE;
    }

    /**
     * 识别数据库类型
     */
    public static DatabaseType identifyDatabaseType(String jdbcUrl) {
        if (jdbcUrl.startsWith("jdbc:mysql:")) {
            return DatabaseType.MYSQL;
        } else if (jdbcUrl.startsWith("jdbc:oracle:")) {
            return DatabaseType.ORACLE;
        } else if (jdbcUrl.startsWith("jdbc:sqlserver:")) {
            return DatabaseType.SQLSERVER;
        } else if (jdbcUrl.startsWith("jdbc:postgresql:")) {
            return DatabaseType.POSTGRESQL;
        } else if (jdbcUrl.startsWith("jdbc:db2:")) {
            return DatabaseType.DB2;
        } else if (jdbcUrl.startsWith("jdbc:sqlite:")) {
            return DatabaseType.SQLITE;
        } else {
            throw new IllegalArgumentException("不支持的数据库类型: " + jdbcUrl);
        }
    }

    /**
     * 测试数据库连接是否有效
     * @param configBO 数据库配置实体，包含连接信息
     * @return 连接测试结果VO
     */
    public static ConnectionVO testConnection(DatabaseConfigEntity configBO) {
        ConnectionVO result = new ConnectionVO();
        Connection connection = null;
        try {
            // 根据数据库类型构建正确的JDBC URL
            String jdbcUrl = buildJdbcUrl(configBO);

            // 获取数据库连接
            connection = ConnectionManager.getConnection(
                    jdbcUrl,
                    configBO.getUsername(),
                    configBO.getPassword()
            );
            // 执行简单查询验证连接有效性
            if (isConnectionValid(connection)) {
                result.setResult(true);
                result.setMessage("数据库连接测试成功");
            } else {
                result.setResult(false);
                result.setMessage("连接已建立但验证失败");
            }
        } catch (Exception e) {
            log.error("数据库连接测试失败, URL: {}, 错误: {}", configBO.getUrl(), e.getMessage());
            result.setResult(false);
            result.setMessage("连接失败: " + e.getMessage());
        } finally {
            // 确保连接关闭
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    log.warn("关闭连接时出错: {}", e.getMessage());
                }
            }
        }
        return result;
    }

    /**
     * 根据配置构建完整的JDBC URL
     */
    private static String buildJdbcUrl(DatabaseConfigEntity config) {
        String ip = config.getUrl();
        String port = config.getPort();
        String dbType = config.getType().toLowerCase();

        switch (dbType) {
            case "mysql":
                return String.format("jdbc:mysql://%s:%s?useSSL=false&serverTimezone=UTC", ip, port);
            case "oracle":
                return String.format("jdbc:oracle:thin:@%s:%s", ip, port);
            case "sqlserver":
                return String.format("jdbc:sqlserver://%s:%s", ip, port);
            case "postgresql":
                return String.format("jdbc:postgresql://%s:%s", ip, port);
            case "sqlite":
                // SQLite通常需要文件路径
                return String.format("jdbc:sqlite:%s", ":memory:");
            default:
                throw new IllegalArgumentException("不支持的数据库类型: " + dbType);
        }
    }

    /**
     * 验证连接是否真正有效
     */
    private static boolean isConnectionValid(Connection conn) {
        if (conn == null) return false;

        try {
            // 设置验证超时时间为5秒
            return conn.isValid(5);
        } catch (SQLException e) {
            return false;
        }
    }
}
